home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / fbug68k.arc / BR.C < prev    next >
C/C++ Source or Header  |  1989-08-17  |  5KB  |  155 lines
  1. #include"userdef.h"
  2.  
  3. /* ****************************************************** */
  4. /* 
  5. br [<addr>][<COUNTDEL><count>]
  6. or
  7. br -r [<addr>]
  8. Break point -> this command either lists all the known break points ("br"),
  9. inserts a break point ("br <addr>[<COUNTDEL><count>]), changes the count
  10. of an existing break point ("br <addr>[<COUNTDEL><count>]"), removes all break
  11. points ("br -r") or remove a specific breakpoint ("br -r <addr>).
  12.  
  13. The objective of this command is to provide a way for users to stop their
  14. programs when they reach a certain address (<addr>) a specified number of times
  15. (<count>). If no count is specified, then the default of 0 is used. This means
  16. the breakpoint will occur the first time the breakpoint is encountered.
  17.  
  18. The way the breakpoint works is to remove a section of code, insert a trap
  19. instruction, then each time the trap is executed, 1 is subtracted from count
  20. until it is negative. This means the count of zero will cause an immediate
  21. break when hit. Negative counts are illegal.
  22.  
  23. The subroutine first checks to see if to many arguments are on the command
  24. line. If so, print an error message and leave. If the number of arguments is 1
  25. then we know all the user wants is a printout of the break points known.
  26.  
  27. If the number of arguments are 2 or 3, known by virtue of getting through
  28. the above to tests, then we strip off the "br " from the front of the command.
  29. Then a check is made for an option delimeter. 
  30.  
  31. If an option delimeter is present, then we need to make sure the option is to
  32. remove ("-r"). Also, we need to know if the number of arguments are 2 or 3.
  33. If 3, then the address of the specific break point is found by getnum. The
  34. breakpoint table is searched  for a match of the address, the match has its
  35. breakpoint changed to -1 (so that it will be ignored later) and all the other
  36. breakpoints are printed. If the number of arguments was 2, then the entire
  37. breakpoint table is searched, and breakpoint with a count greater than zero
  38. has its count changed to zero. In either the 2 or 3 argument case, the
  39. command has done its duty and will fall through to the end to return to
  40. the main loop.
  41.  
  42. If an option delimeter is not present, then we are going to insert or change
  43. a specific break point at address <addr>. First, we get the address. If there
  44. is an error, then we leave. Next, we see if a count delimiter is present. If
  45. so, then we know there will be a <count> and use getnum() to get the count.
  46. If the <COUNTDEL> is absent, then the default of 0 is used for the count.
  47. Now that the <count> is obtained, we go through the list doing three things.
  48. One, we see if we can find a match of the address, indicating we should
  49. change the count. Two, we see if we can find an open slot to stick the 
  50. break point in the table if no match is found. Finally, we print out all
  51. the breakpoints that exist. If no match is made and the table is full, then
  52. a error message is displayed.
  53. */
  54. /* ****************************************************** */
  55.  
  56. brcmd(argc,argv)
  57. int argc;    /* number of arguments on a command line */
  58. char *argv;    /* the command line */
  59. {
  60. extern struct breakelem brtable[];    /* the break table */
  61. extern int error;    /* global flag for an error from getnum() */
  62. register int num;    /* the number of an entry in the break table */
  63. register int open;    /* the number of a free spot in the break table */
  64. register int start;    /* a flag that the new address (or count) is done */
  65. register int addr;    /* an address to be inserted in the break table */
  66. register int count;    /* the count to be inserted in the break table */
  67.  
  68.     if (argc > 3)
  69.         print(ERR01);
  70.     else if (argc == 1)
  71.     {
  72.         print(BRKMSG);
  73.         for (num=0;num < MAXBR;num++)
  74.             if (brtable[num].count >= 0)
  75.                 print("%c%8x:%c%d\n",HEXDEL,brtable[num].address,DECDEL,brtable[num].count);
  76.     }
  77.     else
  78.     {
  79.         striparg(argv);
  80.         if (argv[0] == OPTDEL)
  81.         {
  82.             if (argv[1] == 'r' && argc == 3)
  83.             {
  84.                 striparg(argv);
  85.                 addr = getnum(argv,ERR02, DEFAULTSCALE);
  86.                 if (error)
  87.                     return(0);
  88.                 print(BRKMSG);
  89.                 for (num=0; num < MAXBR;num++)
  90.                 {
  91.                     if(brtable[num].address == addr)
  92.                         brtable[num].count = -1;
  93.                     if (brtable[num].count >= 0)
  94.                         print("%c%8x:%c%d\n",HEXDEL,brtable[num].address,DECDEL,brtable[num].count);
  95.                 }
  96.             }
  97.             else if (argv[1] == 'r' && argc == 2)
  98.             {
  99.                 striparg(argv);
  100.                 print(BRKMSG);
  101.                 for (num=0; num < MAXBR;num++)
  102.                     if (brtable[num].count >= 0)
  103.                         brtable[num].count = -1;
  104.             }
  105.         }    
  106.         else
  107.         {
  108.             addr = getnum(argv,ERR02,DEFAULTSCALE);
  109.             if (error || addr == 0)
  110.                 return(0);
  111.             if (argv[0] == COUNTDEL)
  112.             {
  113.                 shiftarg(argv,1);
  114.                 count = getnum(argv,ERR02,COUNTSCALE);
  115.                 if (count < 0)
  116.                 {
  117.                     print(ERR02);
  118.                     return(0);
  119.                 }
  120.             }
  121.             else
  122.                 count = 0;
  123.             start = FALSE;
  124.             open = -1;
  125.             print(BRKMSG);
  126.             for (num = 0; num < MAXBR; num++)
  127.             {
  128.                 if (brtable[num].address == addr)
  129.                 {
  130.                     start = TRUE;
  131.                     brtable[num].count = count;
  132.                     open = num;
  133.                 }
  134.                 if (open < 0 && brtable[num].count < 0)
  135.                     open = num;
  136.                 if (brtable[num].count >= 0)
  137.                     print("%c%8x:%c%d\n",HEXDEL,brtable[num].address,DECDEL,brtable[num].count);
  138.             }
  139.             if (!start && open >= 0)
  140.             {
  141.                 brtable[open].address = addr;
  142.                 brtable[open].count = count;
  143.                 brtable[open].inst1 = get32(addr);
  144.                 print("%c%8x:%c%d\n",HEXDEL,brtable[open].address,DECDEL,brtable[open].count);
  145.                 start = TRUE;
  146.             }
  147.             if (!start)
  148.                 print(ERR06);
  149.         }
  150.     }
  151. }
  152.  
  153. /* ****************************************************** */
  154.  
  155.